package com.harvey.exampreparation.activity;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

import com.google.android.material.button.MaterialButton;
import com.harvey.exampreparation.R;

/**
 * 生命周期实例兼其他 Activity 的跳转主页
 *
 */
public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private static final String TAG = "LifeCycle";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 生命周期函数日志
        Log.d(TAG, "MainActivity 调用了 onCreate()");

        // 1. 视图绑定
        viewBinding();

        // 2. 行为绑定
        actionBinding();
    }

    private MaterialButton btnGoToBaseViewActivity;         // 用于跳转到基础控件实例 Activity 的按钮
    private MaterialButton btnGoToBaseLayoutActivity;       // 用于跳转到基础布局实例 Activity 的按钮
    private MaterialButton btnGoToListViewActivity;         // 用于跳转到 ListView 实例 Activity 的按钮
    private MaterialButton btnGoToRecyclerViewActivity;     // 用于跳转到 RecyclerView 实例 Activity 的按钮
    private MaterialButton btnOpenDialog;                   // 用于打开对话框 的按钮
    private MaterialButton btnOpenEmpty;                    // 用于跳转到一个空的 Activity 的按钮

    // 通过 findViewById 获取到各个控件的实例
    private void viewBinding() {
        btnGoToBaseViewActivity = findViewById(R.id.btn_goto_base_view);
        btnGoToBaseLayoutActivity = findViewById(R.id.btn_goto_base_layout);
        btnGoToListViewActivity = findViewById(R.id.btn_goto_list_view);
        btnGoToRecyclerViewActivity = findViewById(R.id.btn_goto_recycler_view);
        btnOpenDialog = findViewById(R.id.btn_open_dialog_activity);
        btnOpenEmpty = findViewById(R.id.btn_open_empty_activity);
    }

    /**
     * 设定每一个按钮的监听器, 这里有两种实现方式
     *   一种是使用匿名内部类的方式, 如：
     *         btnGoToBaseViewActivity.setOnClickListener(new View.OnClickListener() {
     *             @Override
     *             public void onClick(View v) {
     *                 startActivity(new Intent(MainActivity.this, BaseViewActivity.class));
     *             }
     *         });
     *    一种是像下面这样, 通过在本 Activity 实现 View.OnClickListener 接口,
     *      直接设置本 Activity 为点击监听器
     */
    private void actionBinding() {
        btnGoToBaseViewActivity.setOnClickListener(this);
        btnGoToBaseLayoutActivity.setOnClickListener(this);
        btnGoToListViewActivity.setOnClickListener(this);
        btnGoToRecyclerViewActivity.setOnClickListener(this);
        btnOpenDialog.setOnClickListener(this);
        btnOpenEmpty.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_goto_base_view:
                startActivity(new Intent(this, BaseViewActivity.class));
                break;
            case R.id.btn_goto_base_layout:
                startActivity(new Intent(this, BaseLayoutActivity.class));
                break;
            case R.id.btn_goto_list_view:
                startActivity(new Intent(this, ListViewActivity.class));
                break;
            case R.id.btn_goto_recycler_view:
                startActivity(new Intent(this, RecyclerViewActivity.class));
                break;
            case R.id.btn_open_dialog_activity:
                startActivity(new Intent(this, DialogActivity.class));
                break;
            case R.id.btn_open_empty_activity:
                startActivity(new Intent(this, EmptyActivity.class));
                break;
        }
    }

    /*
     * 生命周期函数调用
     *  要查看 Activity 生命周期的函数调用日志，
     *  需要打开 Android Studio 下面的 Logcat, 并设定一下 Filter
     *  将 Filter 中的 TAG 设置为 LifeCycle
     *
     *  Activity 中生命周期的一般循序为：
     *    onCreate() -> onStart() -> onResume() -> 启动完成 ->
     *    onPause() -> onStop() -> onDestroy() -> 销毁完成
     *  解析：
     *   当 Activity 到达 onStart() 后, 该 Activity 便进入可见模式；
     *   当 Activity 到达 onResume() 后，该 Activity 便获得了焦点, 进入前景模式；
     *   同样, 当 Activity 在 onPause() 后，该 Activity 便失去了焦点，但此时 Activity 对用户仍是可见的, 所以此时回到了可见模式；
     *   之后，当 Activity 在 onStop() 后，该 Activity 便不可见了，进入了背景模式
     *
     *  然后我们可以来看看, 打开对话框 Activity 之后, Activity 中的生命周期是怎样的
     *  你也可以在该 APP 主页，通过点击打开 DialogActivity 按钮，观察 Logcat 中的内容，来观察生命周期方法的调用顺序
     *  这里用 M 代表本类（MainActivity）用 D 代表对话框（DialogActivity）, 顺序如下：
     *    M.onCreate() -> M.onStart() -> M.onResume() -> MainActivity 启动完成 -> 点击按钮 ->
     *    M.onPause() -> D.onCreate() -> D.onStart() -> D.onResume() -> DialogActivity 启动完成 -> 点击返回 ->
     *    D.onPause() -> M.onResume() -> D.onStop() -> D.onDestroy() -> DialogActivity 销毁完成
     *  解析：
     *    因为对话框只是占据了屏幕中的一部分, MainActivity 仍然在背景可见, 所以只调用了 onPause() 回到了可见模式，
     *    在返回的时候，为了 MainActivity 能够更快得获得焦点, DialogActivity 在失去焦点后立刻让 MainActivity onResume 重获焦点
     *    之后才进行 onStop、onDestroy 销毁工作
     *
     *  最后来看下 Activity 跳转时的生命周期调用顺序, 这里新 Activity 会占据屏幕所有的空间, 旧 Activity 将不可见
     *  你也可以在该 APP 主页，通过点击打开 EmptyActivity 按钮，观察 Logcat 中的内容，来观察生命周期方法的调用顺序
     *  这里用 M 代表本类（MainActivity）用 E 代表新的空Activity（EmptyActivity）, 顺序如下：
     *    M.onCreate() -> M.onStart() -> M.onResume() -> MainActivity 启动完成 -> 点击按钮 ->
     *    M.onPause() -> E.onCreate() -> E.onStart() -> E.onResume() -> EmptyActivity 启动完成 -> M.onStop() -> 点击返回 ->
     *    E.onPause() -> M.onStart() -> M.onResume() -> MainActivity 恢复完成 -> E.onStop() -> E.onDestroy()
     *  解析：
     *    这里跟上面跳转 DialogActivity 十分相似, 唯一区别是在新的 Activity 启动完成后还需要执行 MainActivity 的 onStop,
     *    因为在这里的跳转, MainActivity 已经完全不可见了, 所以 MainActivity 会退出可见模式进入背景模式, 同样, 在返回时,
     *    EmptyActivity 调用 onPause 后就立即执行 MainActivity 的生命周期, 之后再执行 onStop、onDestroy, 也是为了
     *    MainActivity 能够更快得可见
     */

    @Override
    protected void onStart() {
        super.onStart();
        Log.d(TAG, "MainActivity 调用了 onStart()");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d(TAG, "MainActivity 调用了 onResume()");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d(TAG, "MainActivity 调用了 onPause()");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d(TAG, "MainActivity 调用了 onStop()");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "MainActivity 调用了 onDestroy()");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d(TAG, "MainActivity 调用了 onRestart()");
    }
}